#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<string>
#include<set>
#include<vector>
#include<unordered_map>
#include<queue>
#include<list>
using namespace std;

//int main()
//{
//    int a;
//    cin >> a;
//    while (a--)
//    {
//        int n, k;
//        cin >> n >> k;
//        string s;
//        s.reserve(n);
//        cin >> s;
//
//        int ret = 0;
//        int flag = 0;
//        for (int i = 0; i < n; ++i)
//        {
//            if (s[i] == 'L')
//            {
//                --ret;
//                flag = 0;
//            }
//            else
//            {
//                if (flag >= 2)
//                    ret += k;
//                else
//                    ++ret;
//                ++flag;
//            }
//        }
//        cout << ret << endl;
//    }
//    return 0;
//}


//class Solution {
//public:
//
//    int maxLength(vector<int>& arr)
//    {
//        set<int> set(arr.begin(), arr.end());
//        return set.size();
//    }
//};


//class Solution {
//public:
//
//    int maxLength(vector<int>& arr)
//    {
//        int len = arr.size();
//        unordered_map<int, int> hash;
//        hash.rehash(len);
//
//        vector<int> ret(1, 1);
//        for (int i = 1; i < len; ++i)
//        {
//            hash.insert({ arr[i - 1], i - 1 });
//            auto it = hash.find(arr[i]);
//            if (it == hash.end())
//            {
//                ++ret[ret.size() - 1];
//            }
//            else
//            {
//                int i = it->second + 1;
//                hash.clear();
//                ret.push_back(1);
//            }
//        }
//
//        int max = 0;
//        for (int i = 0; i < ret.size(); ++i)
//        {
//            if (ret[i] > max)
//                max = ret[i];
//        }
//        return max;
//    }
//};
//int main()
//{
//    vector<int> v = { 1,2,3,1,2,3,2,2 };
//    cout << Solution().maxLength(v) << endl;
//    return 0;
//}


//int main() 
//{
//    int n;
//    while (cin >> n)
//    {
//        string s;
//        s.reserve(n);
//        cin >> s;
//
//        int hash[26] = { 0 };
//        for (int i = 0; i < n; ++i)
//        {
//            ++hash[s[i] - 'a'];
//        }
//    }
//    return 0;
//}

//int main()
//{
//	priority_queue<int> pq;
//	cout << pq.top() << endl;
//	return 0;
//}



//struct Less
//{
//    bool operator()(pair<int, char> p1, pair<int, char> p2)
//    {
//        return p1.first < p2.first;
//    }
//};
//int main() {
//    int n;
//    while (cin >> n)
//    {
//        string s;
//        s.reserve(n);
//        cin >> s;
//
//        int hash[26] = { 0 };
//        for (int i = 0; i < n; ++i)
//        {
//            ++hash[s[i] - 'a'];
//        }
//
//        string ret;
//        ret.reserve(n);
//        priority_queue<pair<int, char>, vector<pair<int, char>>, Less> pq;
//        for (int i = 0; i < 26; ++i)
//        {
//            if (hash[i])
//                pq.push({ hash[i], i + 'a' });
//        }
//        int flag = 1;
//        while (pq.size())
//        {
//            pair<int, char> tmp = pq.top();
//            if (ret.size() == 0)
//            {
//                ret += tmp.second;
//                pq.pop();
//                if (tmp.first > 1)
//                    pq.push({ tmp.first - 1, tmp.second });
//            }
//            else
//            {
//                if (tmp.second != ret[ret.size() - 1])
//                {
//                    ret += tmp.second;
//                    pq.pop();
//                    if (tmp.first > 1)
//                        pq.push({ tmp.first - 1, tmp.second });
//                }
//                else
//                {
//                    if (pq.size() == 1)
//                    {
//                        cout << "no" << endl;
//                        flag = 0;
//                        break;
//                    }
//                    else
//                    {
//                        pq.pop();
//                        pair<int, char> next_tmp = pq.top();
//                        ret += next_tmp.second;
//                        pq.pop();
//                        if (next_tmp.first > 1)
//                            pq.push({ next_tmp.first - 1, tmp.second });
//                        pq.push(tmp);
//                    }
//                }
//            }
//        }
//        if (flag)
//            cout << "yes" << endl << ret << endl;
//
//    }
//    return 0;
//}
struct Greater
{
    bool operator()(pair<int, char> p1, pair<int, char> p2)
    {
        return p1.first > p2.first;
    }
};
struct Greater
{
    bool operator()(pair<int, char> p1, pair<int, char> p2)
    {
        return p1.first > p2.first;
    }
};
struct Greater
{
    bool operator()(pair<int, char> p1, pair<int, char> p2)
    {
        return p1.first > p2.first;
    }
};
int main() {
    int n;
    while (cin >> n)
    {
        string s;
        s.reserve(n);
        cin >> s;

        int hash[26] = { 0 };
        for (int i = 0; i < n; ++i)
        {
            ++hash[s[i] - 'a'];
        }

        int max = 0;
        for (int i = 0; i < 26; ++i)
        {
            if (hash[i] > max)
                max = hash[i];
        }

        if (max > n - max + 1)
            cout << "no" << endl;

        else
        {
            string ret;
            ret.reserve(n);
            list<pair<int, char>> v;
            for (int i = 0; i < 26; ++i)
            {
                if (hash[i])
                    v.push_back({ hash[i], i + 'a' });
            }
            v.sort(Greater());

            while (v.size())
            {
                auto next = v.begin();
                if (next->second == ret[ret.size() - 1]) ++next;
                ret += next->second;
                --next->first;
                if (next->first == 0) v.erase(next);
                v.sort(Greater());
            }
            cout << "yes" << endl << ret << endl;
        }
    }
    return 0;
}
